/**
 * This is a generated class and is not intended for modfication.  To customize behavior
 * of this value object you may modify the generated sub-class of this class - PlanAdjustDatagrid.as.
 */

package valueObjects
{
import com.adobe.fiber.services.IFiberManagingService;
import com.adobe.fiber.valueobjects.IValueObject;
import flash.events.Event;
import flash.events.EventDispatcher;
import mx.events.PropertyChangeEvent;
import valueObjects.Timestamp;

import flash.net.registerClassAlias;
import flash.net.getClassByAlias;
import com.adobe.fiber.core.model_internal;
import com.adobe.fiber.valueobjects.IPropertyIterator;
import com.adobe.fiber.valueobjects.AvailablePropertyIterator;

use namespace model_internal;

[ExcludeClass]
public class _Super_PlanAdjustDatagrid extends flash.events.EventDispatcher implements com.adobe.fiber.valueobjects.IValueObject
{
    model_internal static function initRemoteClassAliasSingle(cz:Class) : void 
    {
        try 
        {
            if (flash.net.getClassByAlias("edu.whu.bsrms.plan.model.PlanAdjustDatagrid") == null)
            {
                flash.net.registerClassAlias("edu.whu.bsrms.plan.model.PlanAdjustDatagrid", cz);
            } 
        }
        catch (e:Error) 
        {
            flash.net.registerClassAlias("edu.whu.bsrms.plan.model.PlanAdjustDatagrid", cz); 
        }
    }   
     
    model_internal static function initRemoteClassAliasAllRelated() : void 
    {
        valueObjects.Timestamp.initRemoteClassAliasSingleChild();
    }

	model_internal var _dminternal_model : _PlanAdjustDatagridEntityMetadata;

	/**
	 * properties
	 */
	private var _internal_lastModifiedTime : Date;
	private var _internal_executeCount : int;
	private var _internal_changeWenshi : int;
	private var _internal_changeCount : int;
	private var _internal_changeLigong : int;
	private var _internal_provinceCode : String;
	private var _internal_applicationId : String;
	private var _internal_state : String;
	private var _internal_afterChangeCount : int;
	private var _internal_id : Number;
	private var _internal_province : String;
	private var _internal_planWenshi : int;
	private var _internal_leibie : String;
	private var _internal_executeWenshi : int;
	private var _internal_isAlive : int;
	private var _internal_piciCode : String;
	private var _internal_pici : String;
	private var _internal_changeYishuli : int;
	private var _internal_changeYishuwen : int;
	private var _internal_afterChangeYishuwen : int;
	private var _internal_afterChangeLigong : int;
	private var _internal_afterChangeWenshi : int;
	private var _internal_planYishuli : int;
	private var _internal_adjustTime : Date;
	private var _internal_executeLigong : int;
	private var _internal_adjustCount : int;
	private var _internal_afterChangeYishuli : int;
	private var _internal_executeYishuwen : int;
	private var _internal_executeYishuli : int;
	private var _internal_planCount : int;
	private var _internal_planYishuwen : int;
	private var _internal_planLigong : int;

    private static var emptyArray:Array = new Array();

    /**
     * derived property cache initialization
     */  
    model_internal var _cacheInitialized_isValid:Boolean = false;   
    
	model_internal var _changeWatcherArray:Array = new Array();   

	public function _Super_PlanAdjustDatagrid() 
	{	
		_model = new _PlanAdjustDatagridEntityMetadata(this);
	
		// Bind to own data properties for cache invalidation triggering  
       
	}

    /**
     * data property getters
     */
	[Bindable(event="propertyChange")] 
    public function get lastModifiedTime() : Date    
    {
            return _internal_lastModifiedTime;
    }    
	[Bindable(event="propertyChange")] 
    public function get executeCount() : int    
    {
            return _internal_executeCount;
    }    
	[Bindable(event="propertyChange")] 
    public function get changeWenshi() : int    
    {
            return _internal_changeWenshi;
    }    
	[Bindable(event="propertyChange")] 
    public function get changeCount() : int    
    {
            return _internal_changeCount;
    }    
	[Bindable(event="propertyChange")] 
    public function get changeLigong() : int    
    {
            return _internal_changeLigong;
    }    
	[Bindable(event="propertyChange")] 
    public function get provinceCode() : String    
    {
            return _internal_provinceCode;
    }    
	[Bindable(event="propertyChange")] 
    public function get applicationId() : String    
    {
            return _internal_applicationId;
    }    
	[Bindable(event="propertyChange")] 
    public function get state() : String    
    {
            return _internal_state;
    }    
	[Bindable(event="propertyChange")] 
    public function get afterChangeCount() : int    
    {
            return _internal_afterChangeCount;
    }    
	[Bindable(event="propertyChange")] 
    public function get id() : Number    
    {
            return _internal_id;
    }    
	[Bindable(event="propertyChange")] 
    public function get province() : String    
    {
            return _internal_province;
    }    
	[Bindable(event="propertyChange")] 
    public function get planWenshi() : int    
    {
            return _internal_planWenshi;
    }    
	[Bindable(event="propertyChange")] 
    public function get leibie() : String    
    {
            return _internal_leibie;
    }    
	[Bindable(event="propertyChange")] 
    public function get executeWenshi() : int    
    {
            return _internal_executeWenshi;
    }    
	[Bindable(event="propertyChange")] 
    public function get isAlive() : int    
    {
            return _internal_isAlive;
    }    
	[Bindable(event="propertyChange")] 
    public function get piciCode() : String    
    {
            return _internal_piciCode;
    }    
	[Bindable(event="propertyChange")] 
    public function get pici() : String    
    {
            return _internal_pici;
    }    
	[Bindable(event="propertyChange")] 
    public function get changeYishuli() : int    
    {
            return _internal_changeYishuli;
    }    
	[Bindable(event="propertyChange")] 
    public function get changeYishuwen() : int    
    {
            return _internal_changeYishuwen;
    }    
	[Bindable(event="propertyChange")] 
    public function get afterChangeYishuwen() : int    
    {
            return _internal_afterChangeYishuwen;
    }    
	[Bindable(event="propertyChange")] 
    public function get afterChangeLigong() : int    
    {
            return _internal_afterChangeLigong;
    }    
	[Bindable(event="propertyChange")] 
    public function get afterChangeWenshi() : int    
    {
            return _internal_afterChangeWenshi;
    }    
	[Bindable(event="propertyChange")] 
    public function get planYishuli() : int    
    {
            return _internal_planYishuli;
    }    
	[Bindable(event="propertyChange")] 
    public function get adjustTime() : Date    
    {
            return _internal_adjustTime;
    }    
	[Bindable(event="propertyChange")] 
    public function get executeLigong() : int    
    {
            return _internal_executeLigong;
    }    
	[Bindable(event="propertyChange")] 
    public function get adjustCount() : int    
    {
            return _internal_adjustCount;
    }    
	[Bindable(event="propertyChange")] 
    public function get afterChangeYishuli() : int    
    {
            return _internal_afterChangeYishuli;
    }    
	[Bindable(event="propertyChange")] 
    public function get executeYishuwen() : int    
    {
            return _internal_executeYishuwen;
    }    
	[Bindable(event="propertyChange")] 
    public function get executeYishuli() : int    
    {
            return _internal_executeYishuli;
    }    
	[Bindable(event="propertyChange")] 
    public function get planCount() : int    
    {
            return _internal_planCount;
    }    
	[Bindable(event="propertyChange")] 
    public function get planYishuwen() : int    
    {
            return _internal_planYishuwen;
    }    
	[Bindable(event="propertyChange")] 
    public function get planLigong() : int    
    {
            return _internal_planLigong;
    }    

    /**
     * data property setters
     */      
    public function set lastModifiedTime(value:Date) : void 
    {    	
        var recalcValid:Boolean = false;
    	
    	
    	var oldValue:Date = _internal_lastModifiedTime;               
        if (oldValue !== value)
        {
            _internal_lastModifiedTime = value;
        	this.dispatchEvent(mx.events.PropertyChangeEvent.createUpdateEvent(this, "lastModifiedTime", oldValue, _internal_lastModifiedTime));
        }    	     
        
        if (recalcValid && model_internal::_cacheInitialized_isValid)
        {
            model_internal::isValid_der = model_internal::calculateIsValid();
        }  
    }    
    public function set executeCount(value:int) : void 
    {    	
        var recalcValid:Boolean = false;
    	
    	
    	var oldValue:int = _internal_executeCount;               
        if (oldValue !== value)
        {
            _internal_executeCount = value;
        	this.dispatchEvent(mx.events.PropertyChangeEvent.createUpdateEvent(this, "executeCount", oldValue, _internal_executeCount));
        }    	     
        
        if (recalcValid && model_internal::_cacheInitialized_isValid)
        {
            model_internal::isValid_der = model_internal::calculateIsValid();
        }  
    }    
    public function set changeWenshi(value:int) : void 
    {    	
        var recalcValid:Boolean = false;
    	
    	
    	var oldValue:int = _internal_changeWenshi;               
        if (oldValue !== value)
        {
            _internal_changeWenshi = value;
        	this.dispatchEvent(mx.events.PropertyChangeEvent.createUpdateEvent(this, "changeWenshi", oldValue, _internal_changeWenshi));
        }    	     
        
        if (recalcValid && model_internal::_cacheInitialized_isValid)
        {
            model_internal::isValid_der = model_internal::calculateIsValid();
        }  
    }    
    public function set changeCount(value:int) : void 
    {    	
        var recalcValid:Boolean = false;
    	
    	
    	var oldValue:int = _internal_changeCount;               
        if (oldValue !== value)
        {
            _internal_changeCount = value;
        	this.dispatchEvent(mx.events.PropertyChangeEvent.createUpdateEvent(this, "changeCount", oldValue, _internal_changeCount));
        }    	     
        
        if (recalcValid && model_internal::_cacheInitialized_isValid)
        {
            model_internal::isValid_der = model_internal::calculateIsValid();
        }  
    }    
    public function set changeLigong(value:int) : void 
    {    	
        var recalcValid:Boolean = false;
    	
    	
    	var oldValue:int = _internal_changeLigong;               
        if (oldValue !== value)
        {
            _internal_changeLigong = value;
        	this.dispatchEvent(mx.events.PropertyChangeEvent.createUpdateEvent(this, "changeLigong", oldValue, _internal_changeLigong));
        }    	     
        
        if (recalcValid && model_internal::_cacheInitialized_isValid)
        {
            model_internal::isValid_der = model_internal::calculateIsValid();
        }  
    }    
    public function set provinceCode(value:String) : void 
    {    	
        var recalcValid:Boolean = false;
    	
    	
    	var oldValue:String = _internal_provinceCode;               
        if (oldValue !== value)
        {
            _internal_provinceCode = value;
        	this.dispatchEvent(mx.events.PropertyChangeEvent.createUpdateEvent(this, "provinceCode", oldValue, _internal_provinceCode));
        }    	     
        
        if (recalcValid && model_internal::_cacheInitialized_isValid)
        {
            model_internal::isValid_der = model_internal::calculateIsValid();
        }  
    }    
    public function set applicationId(value:String) : void 
    {    	
        var recalcValid:Boolean = false;
    	
    	
    	var oldValue:String = _internal_applicationId;               
        if (oldValue !== value)
        {
            _internal_applicationId = value;
        	this.dispatchEvent(mx.events.PropertyChangeEvent.createUpdateEvent(this, "applicationId", oldValue, _internal_applicationId));
        }    	     
        
        if (recalcValid && model_internal::_cacheInitialized_isValid)
        {
            model_internal::isValid_der = model_internal::calculateIsValid();
        }  
    }    
    public function set state(value:String) : void 
    {    	
        var recalcValid:Boolean = false;
    	
    	
    	var oldValue:String = _internal_state;               
        if (oldValue !== value)
        {
            _internal_state = value;
        	this.dispatchEvent(mx.events.PropertyChangeEvent.createUpdateEvent(this, "state", oldValue, _internal_state));
        }    	     
        
        if (recalcValid && model_internal::_cacheInitialized_isValid)
        {
            model_internal::isValid_der = model_internal::calculateIsValid();
        }  
    }    
    public function set afterChangeCount(value:int) : void 
    {    	
        var recalcValid:Boolean = false;
    	
    	
    	var oldValue:int = _internal_afterChangeCount;               
        if (oldValue !== value)
        {
            _internal_afterChangeCount = value;
        	this.dispatchEvent(mx.events.PropertyChangeEvent.createUpdateEvent(this, "afterChangeCount", oldValue, _internal_afterChangeCount));
        }    	     
        
        if (recalcValid && model_internal::_cacheInitialized_isValid)
        {
            model_internal::isValid_der = model_internal::calculateIsValid();
        }  
    }    
    public function set id(value:Number) : void 
    {    	
        var recalcValid:Boolean = false;
    	
    	
    	var oldValue:Number = _internal_id;               
        if (oldValue !== value)
        {
            _internal_id = value;
        	this.dispatchEvent(mx.events.PropertyChangeEvent.createUpdateEvent(this, "id", oldValue, _internal_id));
        }    	     
        
        if (recalcValid && model_internal::_cacheInitialized_isValid)
        {
            model_internal::isValid_der = model_internal::calculateIsValid();
        }  
    }    
    public function set province(value:String) : void 
    {    	
        var recalcValid:Boolean = false;
    	
    	
    	var oldValue:String = _internal_province;               
        if (oldValue !== value)
        {
            _internal_province = value;
        	this.dispatchEvent(mx.events.PropertyChangeEvent.createUpdateEvent(this, "province", oldValue, _internal_province));
        }    	     
        
        if (recalcValid && model_internal::_cacheInitialized_isValid)
        {
            model_internal::isValid_der = model_internal::calculateIsValid();
        }  
    }    
    public function set planWenshi(value:int) : void 
    {    	
        var recalcValid:Boolean = false;
    	
    	
    	var oldValue:int = _internal_planWenshi;               
        if (oldValue !== value)
        {
            _internal_planWenshi = value;
        	this.dispatchEvent(mx.events.PropertyChangeEvent.createUpdateEvent(this, "planWenshi", oldValue, _internal_planWenshi));
        }    	     
        
        if (recalcValid && model_internal::_cacheInitialized_isValid)
        {
            model_internal::isValid_der = model_internal::calculateIsValid();
        }  
    }    
    public function set leibie(value:String) : void 
    {    	
        var recalcValid:Boolean = false;
    	
    	
    	var oldValue:String = _internal_leibie;               
        if (oldValue !== value)
        {
            _internal_leibie = value;
        	this.dispatchEvent(mx.events.PropertyChangeEvent.createUpdateEvent(this, "leibie", oldValue, _internal_leibie));
        }    	     
        
        if (recalcValid && model_internal::_cacheInitialized_isValid)
        {
            model_internal::isValid_der = model_internal::calculateIsValid();
        }  
    }    
    public function set executeWenshi(value:int) : void 
    {    	
        var recalcValid:Boolean = false;
    	
    	
    	var oldValue:int = _internal_executeWenshi;               
        if (oldValue !== value)
        {
            _internal_executeWenshi = value;
        	this.dispatchEvent(mx.events.PropertyChangeEvent.createUpdateEvent(this, "executeWenshi", oldValue, _internal_executeWenshi));
        }    	     
        
        if (recalcValid && model_internal::_cacheInitialized_isValid)
        {
            model_internal::isValid_der = model_internal::calculateIsValid();
        }  
    }    
    public function set isAlive(value:int) : void 
    {    	
        var recalcValid:Boolean = false;
    	
    	
    	var oldValue:int = _internal_isAlive;               
        if (oldValue !== value)
        {
            _internal_isAlive = value;
        	this.dispatchEvent(mx.events.PropertyChangeEvent.createUpdateEvent(this, "isAlive", oldValue, _internal_isAlive));
        }    	     
        
        if (recalcValid && model_internal::_cacheInitialized_isValid)
        {
            model_internal::isValid_der = model_internal::calculateIsValid();
        }  
    }    
    public function set piciCode(value:String) : void 
    {    	
        var recalcValid:Boolean = false;
    	
    	
    	var oldValue:String = _internal_piciCode;               
        if (oldValue !== value)
        {
            _internal_piciCode = value;
        	this.dispatchEvent(mx.events.PropertyChangeEvent.createUpdateEvent(this, "piciCode", oldValue, _internal_piciCode));
        }    	     
        
        if (recalcValid && model_internal::_cacheInitialized_isValid)
        {
            model_internal::isValid_der = model_internal::calculateIsValid();
        }  
    }    
    public function set pici(value:String) : void 
    {    	
        var recalcValid:Boolean = false;
    	
    	
    	var oldValue:String = _internal_pici;               
        if (oldValue !== value)
        {
            _internal_pici = value;
        	this.dispatchEvent(mx.events.PropertyChangeEvent.createUpdateEvent(this, "pici", oldValue, _internal_pici));
        }    	     
        
        if (recalcValid && model_internal::_cacheInitialized_isValid)
        {
            model_internal::isValid_der = model_internal::calculateIsValid();
        }  
    }    
    public function set changeYishuli(value:int) : void 
    {    	
        var recalcValid:Boolean = false;
    	
    	
    	var oldValue:int = _internal_changeYishuli;               
        if (oldValue !== value)
        {
            _internal_changeYishuli = value;
        	this.dispatchEvent(mx.events.PropertyChangeEvent.createUpdateEvent(this, "changeYishuli", oldValue, _internal_changeYishuli));
        }    	     
        
        if (recalcValid && model_internal::_cacheInitialized_isValid)
        {
            model_internal::isValid_der = model_internal::calculateIsValid();
        }  
    }    
    public function set changeYishuwen(value:int) : void 
    {    	
        var recalcValid:Boolean = false;
    	
    	
    	var oldValue:int = _internal_changeYishuwen;               
        if (oldValue !== value)
        {
            _internal_changeYishuwen = value;
        	this.dispatchEvent(mx.events.PropertyChangeEvent.createUpdateEvent(this, "changeYishuwen", oldValue, _internal_changeYishuwen));
        }    	     
        
        if (recalcValid && model_internal::_cacheInitialized_isValid)
        {
            model_internal::isValid_der = model_internal::calculateIsValid();
        }  
    }    
    public function set afterChangeYishuwen(value:int) : void 
    {    	
        var recalcValid:Boolean = false;
    	
    	
    	var oldValue:int = _internal_afterChangeYishuwen;               
        if (oldValue !== value)
        {
            _internal_afterChangeYishuwen = value;
        	this.dispatchEvent(mx.events.PropertyChangeEvent.createUpdateEvent(this, "afterChangeYishuwen", oldValue, _internal_afterChangeYishuwen));
        }    	     
        
        if (recalcValid && model_internal::_cacheInitialized_isValid)
        {
            model_internal::isValid_der = model_internal::calculateIsValid();
        }  
    }    
    public function set afterChangeLigong(value:int) : void 
    {    	
        var recalcValid:Boolean = false;
    	
    	
    	var oldValue:int = _internal_afterChangeLigong;               
        if (oldValue !== value)
        {
            _internal_afterChangeLigong = value;
        	this.dispatchEvent(mx.events.PropertyChangeEvent.createUpdateEvent(this, "afterChangeLigong", oldValue, _internal_afterChangeLigong));
        }    	     
        
        if (recalcValid && model_internal::_cacheInitialized_isValid)
        {
            model_internal::isValid_der = model_internal::calculateIsValid();
        }  
    }    
    public function set afterChangeWenshi(value:int) : void 
    {    	
        var recalcValid:Boolean = false;
    	
    	
    	var oldValue:int = _internal_afterChangeWenshi;               
        if (oldValue !== value)
        {
            _internal_afterChangeWenshi = value;
        	this.dispatchEvent(mx.events.PropertyChangeEvent.createUpdateEvent(this, "afterChangeWenshi", oldValue, _internal_afterChangeWenshi));
        }    	     
        
        if (recalcValid && model_internal::_cacheInitialized_isValid)
        {
            model_internal::isValid_der = model_internal::calculateIsValid();
        }  
    }    
    public function set planYishuli(value:int) : void 
    {    	
        var recalcValid:Boolean = false;
    	
    	
    	var oldValue:int = _internal_planYishuli;               
        if (oldValue !== value)
        {
            _internal_planYishuli = value;
        	this.dispatchEvent(mx.events.PropertyChangeEvent.createUpdateEvent(this, "planYishuli", oldValue, _internal_planYishuli));
        }    	     
        
        if (recalcValid && model_internal::_cacheInitialized_isValid)
        {
            model_internal::isValid_der = model_internal::calculateIsValid();
        }  
    }    
    public function set adjustTime(value:Date) : void 
    {    	
        var recalcValid:Boolean = false;
    	
    	
    	var oldValue:Date = _internal_adjustTime;               
        if (oldValue !== value)
        {
            _internal_adjustTime = value;
        	this.dispatchEvent(mx.events.PropertyChangeEvent.createUpdateEvent(this, "adjustTime", oldValue, _internal_adjustTime));
        }    	     
        
        if (recalcValid && model_internal::_cacheInitialized_isValid)
        {
            model_internal::isValid_der = model_internal::calculateIsValid();
        }  
    }    
    public function set executeLigong(value:int) : void 
    {    	
        var recalcValid:Boolean = false;
    	
    	
    	var oldValue:int = _internal_executeLigong;               
        if (oldValue !== value)
        {
            _internal_executeLigong = value;
        	this.dispatchEvent(mx.events.PropertyChangeEvent.createUpdateEvent(this, "executeLigong", oldValue, _internal_executeLigong));
        }    	     
        
        if (recalcValid && model_internal::_cacheInitialized_isValid)
        {
            model_internal::isValid_der = model_internal::calculateIsValid();
        }  
    }    
    public function set adjustCount(value:int) : void 
    {    	
        var recalcValid:Boolean = false;
    	
    	
    	var oldValue:int = _internal_adjustCount;               
        if (oldValue !== value)
        {
            _internal_adjustCount = value;
        	this.dispatchEvent(mx.events.PropertyChangeEvent.createUpdateEvent(this, "adjustCount", oldValue, _internal_adjustCount));
        }    	     
        
        if (recalcValid && model_internal::_cacheInitialized_isValid)
        {
            model_internal::isValid_der = model_internal::calculateIsValid();
        }  
    }    
    public function set afterChangeYishuli(value:int) : void 
    {    	
        var recalcValid:Boolean = false;
    	
    	
    	var oldValue:int = _internal_afterChangeYishuli;               
        if (oldValue !== value)
        {
            _internal_afterChangeYishuli = value;
        	this.dispatchEvent(mx.events.PropertyChangeEvent.createUpdateEvent(this, "afterChangeYishuli", oldValue, _internal_afterChangeYishuli));
        }    	     
        
        if (recalcValid && model_internal::_cacheInitialized_isValid)
        {
            model_internal::isValid_der = model_internal::calculateIsValid();
        }  
    }    
    public function set executeYishuwen(value:int) : void 
    {    	
        var recalcValid:Boolean = false;
    	
    	
    	var oldValue:int = _internal_executeYishuwen;               
        if (oldValue !== value)
        {
            _internal_executeYishuwen = value;
        	this.dispatchEvent(mx.events.PropertyChangeEvent.createUpdateEvent(this, "executeYishuwen", oldValue, _internal_executeYishuwen));
        }    	     
        
        if (recalcValid && model_internal::_cacheInitialized_isValid)
        {
            model_internal::isValid_der = model_internal::calculateIsValid();
        }  
    }    
    public function set executeYishuli(value:int) : void 
    {    	
        var recalcValid:Boolean = false;
    	
    	
    	var oldValue:int = _internal_executeYishuli;               
        if (oldValue !== value)
        {
            _internal_executeYishuli = value;
        	this.dispatchEvent(mx.events.PropertyChangeEvent.createUpdateEvent(this, "executeYishuli", oldValue, _internal_executeYishuli));
        }    	     
        
        if (recalcValid && model_internal::_cacheInitialized_isValid)
        {
            model_internal::isValid_der = model_internal::calculateIsValid();
        }  
    }    
    public function set planCount(value:int) : void 
    {    	
        var recalcValid:Boolean = false;
    	
    	
    	var oldValue:int = _internal_planCount;               
        if (oldValue !== value)
        {
            _internal_planCount = value;
        	this.dispatchEvent(mx.events.PropertyChangeEvent.createUpdateEvent(this, "planCount", oldValue, _internal_planCount));
        }    	     
        
        if (recalcValid && model_internal::_cacheInitialized_isValid)
        {
            model_internal::isValid_der = model_internal::calculateIsValid();
        }  
    }    
    public function set planYishuwen(value:int) : void 
    {    	
        var recalcValid:Boolean = false;
    	
    	
    	var oldValue:int = _internal_planYishuwen;               
        if (oldValue !== value)
        {
            _internal_planYishuwen = value;
        	this.dispatchEvent(mx.events.PropertyChangeEvent.createUpdateEvent(this, "planYishuwen", oldValue, _internal_planYishuwen));
        }    	     
        
        if (recalcValid && model_internal::_cacheInitialized_isValid)
        {
            model_internal::isValid_der = model_internal::calculateIsValid();
        }  
    }    
    public function set planLigong(value:int) : void 
    {    	
        var recalcValid:Boolean = false;
    	
    	
    	var oldValue:int = _internal_planLigong;               
        if (oldValue !== value)
        {
            _internal_planLigong = value;
        	this.dispatchEvent(mx.events.PropertyChangeEvent.createUpdateEvent(this, "planLigong", oldValue, _internal_planLigong));
        }    	     
        
        if (recalcValid && model_internal::_cacheInitialized_isValid)
        {
            model_internal::isValid_der = model_internal::calculateIsValid();
        }  
    }    

    /**
     * data property setter listeners
     */   

   model_internal function setterListenerAnyConstraint(value:flash.events.Event):void
   {
        if (model_internal::_cacheInitialized_isValid)
        {
            model_internal::isValid_der = model_internal::calculateIsValid();
        }        
   }   

    /**
     * valid related derived properties
     */
    model_internal var _isValid : Boolean;
    model_internal var _invalidConstraints:Array = new Array();
    model_internal var _validationFailureMessages:Array = new Array();

    /**
     * derived property calculators
     */

    /**
     * isValid calculator
     */
    model_internal function calculateIsValid():Boolean
    {
        var violatedConsts:Array = new Array();    
        var validationFailureMessages:Array = new Array();    


		var styleValidity:Boolean = true;
	
	
	
	
	
	
	
	
	
	
	
	
	
	
	
	
	
	
	
	
	
	
	
	
	
	
	
	
	
	
	
	
    
        model_internal::_cacheInitialized_isValid = true;
        model_internal::invalidConstraints_der = violatedConsts;
        model_internal::validationFailureMessages_der = validationFailureMessages;
        return violatedConsts.length == 0 && styleValidity;
    }  

    /**
     * derived property setters
     */

    model_internal function set isValid_der(value:Boolean) : void
    {
       	var oldValue:Boolean = model_internal::_isValid;               
        if (oldValue !== value)
        {
        	model_internal::_isValid = value;
        	_model.model_internal::fireChangeEvent("isValid", oldValue, model_internal::_isValid);
        }        
    }

    /**
     * derived property getters
     */

    [Transient] 
	[Bindable(event="propertyChange")] 
    public function get _model() : _PlanAdjustDatagridEntityMetadata
    {
		return model_internal::_dminternal_model;              
    }	
    
    public function set _model(value : _PlanAdjustDatagridEntityMetadata) : void       
    {
    	var oldValue : _PlanAdjustDatagridEntityMetadata = model_internal::_dminternal_model;               
        if (oldValue !== value)
        {
        	model_internal::_dminternal_model = value;
        	this.dispatchEvent(mx.events.PropertyChangeEvent.createUpdateEvent(this, "_model", oldValue, model_internal::_dminternal_model));
        }     
    }      

    /**
     * methods
     */  


    /**
     *  services
     */                  
     private var _managingService:com.adobe.fiber.services.IFiberManagingService;
    
     public function set managingService(managingService:com.adobe.fiber.services.IFiberManagingService):void
     {
         _managingService = managingService;
     }                      
     
    model_internal function set invalidConstraints_der(value:Array) : void
    {  
     	var oldValue:Array = model_internal::_invalidConstraints;
     	// avoid firing the event when old and new value are different empty arrays
        if (oldValue !== value && (oldValue.length > 0 || value.length > 0))
        {
            model_internal::_invalidConstraints = value;   
			_model.model_internal::fireChangeEvent("invalidConstraints", oldValue, model_internal::_invalidConstraints);   
        }     	             
    }             
    
     model_internal function set validationFailureMessages_der(value:Array) : void
    {  
     	var oldValue:Array = model_internal::_validationFailureMessages;
     	// avoid firing the event when old and new value are different empty arrays
        if (oldValue !== value && (oldValue.length > 0 || value.length > 0))
        {
            model_internal::_validationFailureMessages = value;   
			_model.model_internal::fireChangeEvent("validationFailureMessages", oldValue, model_internal::_validationFailureMessages);   
        }     	             
    }        
     
     // Individual isAvailable functions     
	// fields, getters, and setters for primitive representations of complex id properties

}

}
